const buildData = {
  // 将neo4j的数据转换为AntV数据
  neo4jDataToAntV(neoData) {
    if (neoData.length == 0) {
      return
    }
    const antV = {
      nodes: [],
      edges: []
    }
    // 去重关系
    let setEdge = new Set()
    let setNode = new Set()
    // let map = {}
    const newData = neoData
    // newData.forEach(elent => {
    //   map[elent.n.elementId] = elent.n.properties.id
    //   map[elent.r.elementId] = elent.r.properties.id
    // })

    newData.forEach(item => {
      let nodeObj = {
        // inPoints: [[0, 1], [0, -1], [1, 0], [-1, 0]]
      }
      let edgeObj = {}
      if (Object.keys(item.n).length > 0) {
        Object.assign(nodeObj, item.n.properties)
        // nodeObj.x = Number(nodeObj.x)
        // nodeObj.y = Number(nodeObj.y)
        if (!setNode.has(item.n.elementId)) {
          nodeObj.id = item.n.elementId
          nodeObj.nodeType = item.n.labels[0]
          nodeObj.nodeId = item.n.elementId
          nodeObj.properties = item.n.properties
          setNode.add(item.n.elementId)
          antV.nodes.push(nodeObj)
        }
      }
      if (Object.keys(item.m).length > 0) {
        nodeObj = {}
        Object.assign(nodeObj, item.m.properties)
        // nodeObj.x = Number(nodeObj.x)
        // nodeObj.y = Number(nodeObj.y)
        if (!setNode.has(item.m.elementId)) {
          nodeObj.id = item.m.elementId
          nodeObj.nodeType = item.m.labels[0]
          nodeObj.nodeId = item.m.elementId
          nodeObj.properties = item.m.properties
          setNode.add(item.m.elementId)
          antV.nodes.push(nodeObj)
        }
      }
      if (Object.keys(item.r).length > 0) {
        if (!setEdge.has(item.r.elementId)) {
          // 去重关系
          setEdge.add(item.r.elementId)
          // Object.assign(edgeObj, item.r)
          // if (!item.r.properties.id) {
          edgeObj.id = item.r.elementId
          // }
          edgeObj.start = {}
          edgeObj.end = {}
          edgeObj.sourceId = item.r.startNodeElementId
          edgeObj.source = edgeObj.sourceId
          edgeObj.targetId = item.r.endNodeElementId
          edgeObj.target = edgeObj.targetId
          edgeObj.relationShipName = item.r.type
          edgeObj.id = item.r.elementId
          edgeObj.relationShipId = item.r.elementId
          antV.edges.push(edgeObj)
        }
      }
    })
    const resultObj = {
      nodes: antV.nodes,
      edges: antV.edges
    }
    this.randomColor(resultObj.nodes)
    resultObj.nodes.forEach(item => {
      let propertiesList = []
      const allKey = Object.keys(item.properties)
      const allValue = Object.values(item.properties)
      allKey.forEach((v, index) => {
        if (allValue[index]) {
          propertiesList.push({
            label: v,
            value: allValue[index]
          })
        }
      })
      item.propertyList = propertiesList
    })
    return resultObj
  },
  // 去重节点
  // getUnniBySet(neoData) {
  //   let set = new Set()
  //   let onlyData = []
  //   neoData.forEach(item => {
  //     if (item.n) {
  //       if (!set.has(item.n.properties.id)) {
  //         set.add(item.n.properties.id)
  //         onlyData.push(item)
  //       }
  //     }
  //   })
  //   return onlyData
  // },
  // 随机分配颜色
  randomColor(data) {
    const _that = this
    const labelColors = new Map() // 用于存储 labels 和颜色的映射

    function assignColors(data) {
      data.forEach(item => {
        const assignColor = (obj, key) => {
          if (labelColors.get(obj.nodeType)) {
            obj.color = labelColors.get(obj.nodeType)
          } else {
            labelColors.set(obj.nodeType, _that.getRandomHexColor())
            obj.color = labelColors.get(obj.nodeType)
          }
        }
        assignColor(item)
        assignColor(item)
      })
      return data
    }

    // 使用函数
    const coloredData = assignColors(data)
  },
  getRandomHexColor() {
    let r, g, b

    // 生成RGB颜色值，确保它们不是0或255（即避免黑色和白色）
    do {
      r = Math.floor(Math.random() * 254) + 1 // 随机1到254之间的整数
      g = Math.floor(Math.random() * 254) + 1 // 随机1到254之间的整数
      b = Math.floor(Math.random() * 254) + 1 // 随机1到254之间的整数
    } while (r === g && g === b) // 可选：避免生成灰色调（这一步是可选的，取决于你是否想要完全避免所有可能的灰色）

    // 将RGB值转换为16进制格式
    const toHex = num => {
      const hex = num.toString(16)
      return hex.length === 1 ? '0' + hex : hex // 确保每个颜色分量都是两位数
    }

    // 组合成完整的16进制颜色代码
    const hexColor = `#${toHex(r)}${toHex(g)}${toHex(b)}`
    return hexColor
  }
}
export default buildData
